const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const sqlite3 = require('sqlite3').verbose();
const sqlcipher = require('@journeyapps/sqlcipher').verbose();
const XLSX = require('xlsx');

// 使用纯JavaScript实现Excel解析和SQLite操作
class JSBackend {
  constructor() {
    this.databases = new Map();
  }

  // 解析Excel文件
  parseExcelFile(filePath) {
    try {
      const ext = path.extname(filePath).toLowerCase();
      
      if (ext === '.csv') {
        return this.parseCSV(filePath);
      } else if (ext === '.xlsx' || ext === '.xls') {
        return this.parseExcel(filePath);
      } else {
        throw new Error('不支持的文件格式，请使用 .xlsx、.xls 或 .csv 文件');
      }
    } catch (error) {
      console.error('文件解析错误:', error);
      throw new Error(`文件解析失败: ${error.message}`);
    }
  }

  // 解析Excel文件
  parseExcel(filePath) {
    const workbook = XLSX.readFile(filePath);
    const sheetName = workbook.SheetNames[0]; // 使用第一个工作表
    const worksheet = workbook.Sheets[sheetName];
    
    // 转换为JSON格式
    const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
    
    if (jsonData.length === 0) {
      throw new Error('Excel文件为空');
    }

    // 获取表头
    const headers = jsonData[0].map(header => header ? header.toString().trim() : '');
    
    // 过滤空的表头
    const validHeaders = [];
    const validColumnIndexes = [];
    headers.forEach((header, index) => {
      if (header) {
        validHeaders.push(header);
        validColumnIndexes.push(index);
      }
    });

    if (validHeaders.length === 0) {
      throw new Error('Excel文件没有有效的表头');
    }

    // 解析数据行
    const data = [];
    for (let i = 1; i < jsonData.length; i++) {
      const row = jsonData[i];
      if (row && row.some(cell => cell != null && cell !== '')) {
        const rowData = {};
        validColumnIndexes.forEach((colIndex, headerIndex) => {
          const value = row[colIndex];
          rowData[validHeaders[headerIndex]] = value != null ? value.toString().trim() : '';
        });
        data.push(rowData);
      }
    }

    return {
      headers: validHeaders,
      data,
      rowCount: data.length
    };
  }

  // 解析CSV文件
  parseCSV(filePath) {
    const content = fs.readFileSync(filePath, 'utf-8');
    
    if (!content.trim()) {
      throw new Error('文件为空');
    }

    // 使用更健壮的CSV解析方法
    const rows = this.parseCSVContent(content);
    
    if (rows.length === 0) {
      throw new Error('文件为空');
    }

    // 解析表头
    const headers = rows[0];
    const data = [];

    // 解析数据行
    for (let i = 1; i < rows.length; i++) {
      const values = rows[i];
      if (values.length === headers.length) {
        const row = {};
        headers.forEach((header, index) => {
          row[header] = values[index];
        });
        data.push(row);
      } else {
        // 记录字段数不匹配的行，但不跳过，尝试修复
        console.warn(`行 ${i + 1} 字段数不匹配: 期望 ${headers.length} 个，实际 ${values.length} 个`);
        
        // 尝试修复：如果字段数少于期望，用空值填充
        if (values.length < headers.length) {
          const row = {};
          headers.forEach((header, index) => {
            row[header] = values[index] || '';
          });
          data.push(row);
        }
      }
    }

    return {
      headers,
      data,
      rowCount: data.length
    };
  }

  // 解析CSV内容（处理多行字段）
  parseCSVContent(content) {
    const rows = [];
    let currentRow = [];
    let currentField = '';
    let inQuotes = false;
    let i = 0;
    
    while (i < content.length) {
      const char = content[i];
      
      if (char === '"') {
        if (inQuotes && i + 1 < content.length && content[i + 1] === '"') {
          // 转义的引号
          currentField += '"';
          i += 2;
          continue;
        } else {
          // 切换引号状态
          inQuotes = !inQuotes;
        }
      } else if (char === ',' && !inQuotes) {
        // 字段分隔符
        currentRow.push(currentField.trim());
        currentField = '';
      } else if ((char === '\n' || char === '\r') && !inQuotes) {
        // 行结束
        if (currentField || currentRow.length > 0) {
          currentRow.push(currentField.trim());
          if (currentRow.some(field => field !== '')) {
            rows.push(currentRow);
          }
          currentRow = [];
          currentField = '';
        }
        // 跳过\r\n中的\n
        if (char === '\r' && i + 1 < content.length && content[i + 1] === '\n') {
          i++;
        }
      } else {
        currentField += char;
      }
      
      i++;
    }
    
    // 处理最后一个字段和行
    if (currentField || currentRow.length > 0) {
      currentRow.push(currentField.trim());
      if (currentRow.some(field => field !== '')) {
        rows.push(currentRow);
      }
    }
    
    return rows;
  }

  // 解析CSV行（保留用于向后兼容）
  parseCSVLine(line) {
    const result = [];
    let current = '';
    let inQuotes = false;
    
    for (let i = 0; i < line.length; i++) {
      const char = line[i];
      
      if (char === '"') {
        inQuotes = !inQuotes;
      } else if (char === ',' && !inQuotes) {
        result.push(current.trim());
        current = '';
      } else {
        current += char;
      }
    }
    
    result.push(current.trim());
    return result;
  }

  // 创建SQLite数据库（内存版本）
  createDatabase(name) {
    const db = {
      name,
      tables: new Map(),
      created: new Date()
    };
    
    this.databases.set(name, db);
    return db;
  }

  // 创建表
  createTable(dbName, tableName, columns, data) {
    const db = this.databases.get(dbName);
    if (!db) {
      throw new Error('数据库不存在');
    }

    // 推断列类型
    const columnDefs = columns.map(col => {
      const sampleValues = data.slice(0, 10).map(row => row[col]).filter(v => v != null && v !== '');
      let type = 'TEXT';
      
      if (sampleValues.length > 0) {
        const firstValue = sampleValues[0];
        if (!isNaN(firstValue) && !isNaN(parseFloat(firstValue))) {
          type = firstValue.includes('.') ? 'REAL' : 'INTEGER';
        }
      }
      
      return { name: col, type };
    });

    const table = {
      name: tableName,
      columns: columnDefs,
      data: [...data],
      created: new Date()
    };

    db.tables.set(tableName, table);
    return table;
  }

  // 导出为真正的SQLite数据库文件
  exportToSQLite(parseResult, outputPath, tableName) {
    return new Promise((resolve, reject) => {
      if (!parseResult || !parseResult.data) {
        reject(new Error('解析结果不存在'));
        return;
      }

      // 如果文件已存在，先删除
      if (fs.existsSync(outputPath)) {
        fs.unlinkSync(outputPath);
      }

      // 创建SQLite数据库
      const sqliteDb = new sqlite3.Database(outputPath, (err) => {
        if (err) {
          reject(err);
          return;
        }

        // 串行执行所有操作
        sqliteDb.serialize(() => {
          try {
            // 使用指定的star_table创建语句
            const createTableSQL = `CREATE TABLE star_table ( 
              id INTEGER PRIMARY KEY NOT NULL, 
              category TEXT, 
              no INTEGER, 
              noExt TEXT, 
              isM INTEGER, 
              nameEN TEXT, 
              nameCN TEXT, 
              ra REAL, 
              dec REAL, 
              vmag REAL, 
              sizeX REAL, 
              sizeY REAL, 
              img_SS TEXT, 
              imgC_SS TEXT, 
              img_AIR TEXT, 
              imgC_AIR TEXT, 
              typeCode INTEGER, 
              object_type TEXT, 
              filter INTEGER, 
              remarkEN TEXT, 
              remarkCN TEXT, 
              other_numbers TEXT, 
              con TEXT, 
              brightness TEXT, 
              shape TEXT, 
              radius REAL, 
              diameter REAL, 
              mass REAL, 
              discoverer TEXT, 
              dYearEN TEXT, 
              dYearCN TEXT, 
              vmag1sd REAL, 
              vmag2nd REAL, 
              cloud_area REAL, 
              opacity REAL, 
              DesCN TEXT, 
              DesEn TEXT, 
              S50 INTEGER, 
              recommend_SS INTEGER, 
              rank_SS INTEGER, 
              recommend_ASIAIR INTEGER 
            )`;
            
            sqliteDb.run(createTableSQL, (err) => {
              if (err) {
                console.error('创建表失败:', err);
                reject(err);
                return;
              }

              // INSERT语句 - 使用star_table作为表名
              if (parseResult.data.length > 0) {
                // 定义star_table的所有列名（按顺序）
                const starTableColumns = [
                  'id', 'category', 'no', 'noExt', 'isM', 'nameEN', 'nameCN', 
                  'ra', 'dec', 'vmag', 'sizeX', 'sizeY', 'img_SS', 'imgC_SS', 
                  'img_AIR', 'imgC_AIR', 'typeCode', 'object_type', 'filter', 
                  'remarkEN', 'remarkCN', 'other_numbers', 'con', 'brightness', 
                  'shape', 'radius', 'diameter', 'mass', 'discoverer', 'dYearEN', 
                  'dYearCN', 'vmag1sd', 'vmag2nd', 'cloud_area', 'opacity', 
                  'DesCN', 'DesEn', 'S50', 'recommend_SS', 'rank_SS', 'recommend_ASIAIR'
                ];
                
                const columns = starTableColumns.join(', ');
                const placeholders = starTableColumns.map(() => '?').join(', ');
                const insertSQL = `INSERT INTO star_table (${columns}) VALUES (${placeholders})`;
                
                const stmt = sqliteDb.prepare(insertSQL);
                
                let insertCount = 0;
                let hasError = false;
                const totalRows = parseResult.data.length;
                
                for (const row of parseResult.data) {
                  // 按照star_table的列顺序映射数据
                  const values = starTableColumns.map(colName => {
                    const value = row[colName];
                    if (value == null || value === '') {
                      return null;
                    }
                    return value;
                  });
                  
                  stmt.run(values, (err) => {
                    if (err && !hasError) {
                      hasError = true;
                      console.error('插入数据失败:', err);
                      stmt.finalize();
                      sqliteDb.close();
                      reject(err);
                      return;
                    }
                    
                    insertCount++;
                    if (insertCount === totalRows) {
                      // 所有数据插入完成
                      stmt.finalize((err) => {
                        if (err) {
                          reject(err);
                        } else {
                          // 关闭数据库连接
                          sqliteDb.close((err) => {
                            if (err) {
                              reject(err);
                            } else {
                              console.log(`成功插入 ${insertCount} 行数据到 ${outputPath}`);
                              resolve(outputPath);
                            }
                          });
                        }
                      });
                    }
                  });
                }
              } else {
                // 没有数据时也要关闭数据库
                sqliteDb.close((err) => {
                  if (err) {
                    reject(err);
                  } else {
                    resolve(outputPath);
                  }
                });
              }
            });

          } catch (error) {
            reject(error);
          }
        });
      });
    });
  }

  // 导出为SQLCipher加密数据库文件
  exportToSQLCipher(parseResult, outputPath, tableName, password) {
    return new Promise((resolve, reject) => {
      if (!parseResult || !parseResult.data) {
        reject(new Error('解析结果不存在'));
        return;
      }

      // 如果文件已存在，先删除
      if (fs.existsSync(outputPath)) {
        fs.unlinkSync(outputPath);
      }

      // 创建SQLCipher加密数据库
      const sqliteDb = new sqlcipher.Database(outputPath, (err) => {
        if (err) {
          reject(err);
          return;
        }

        // 设置加密密码
        sqliteDb.run(`PRAGMA key = '${password}'`, (err) => {
          if (err) {
            reject(err);
            return;
          }

          // 串行执行所有操作
          sqliteDb.serialize(() => {
            try {
              // 使用指定的star_table创建语句
              const createTableSQL = `CREATE TABLE star_table ( 
                id INTEGER PRIMARY KEY NOT NULL, 
                category TEXT, 
                no INTEGER, 
                noExt TEXT, 
                isM INTEGER, 
                nameEN TEXT, 
                nameCN TEXT, 
                ra REAL, 
                dec REAL, 
                vmag REAL, 
                sizeX REAL, 
                sizeY REAL, 
                img_SS TEXT, 
                imgC_SS TEXT, 
                img_AIR TEXT, 
                imgC_AIR TEXT, 
                typeCode INTEGER, 
                object_type TEXT, 
                filter INTEGER, 
                remarkEN TEXT, 
                remarkCN TEXT, 
                other_numbers TEXT, 
                con TEXT, 
                brightness TEXT, 
                shape TEXT, 
                radius REAL, 
                diameter REAL, 
                mass REAL, 
                discoverer TEXT, 
                dYearEN TEXT, 
                dYearCN TEXT, 
                vmag1sd REAL, 
                vmag2nd REAL, 
                cloud_area REAL, 
                opacity REAL, 
                DesCN TEXT, 
                DesEn TEXT, 
                S50 INTEGER, 
                recommend_SS INTEGER, 
                rank_SS INTEGER, 
                recommend_ASIAIR INTEGER 
              )`;
              
              sqliteDb.run(createTableSQL, (err) => {
                if (err) {
                  console.error('创建表失败:', err);
                  reject(err);
                  return;
                }

                // INSERT语句 - 使用star_table作为表名
                if (parseResult.data.length > 0) {
                  // 定义star_table的所有列名（按顺序）
                  const starTableColumns = [
                    'id', 'category', 'no', 'noExt', 'isM', 'nameEN', 'nameCN', 
                    'ra', 'dec', 'vmag', 'sizeX', 'sizeY', 'img_SS', 'imgC_SS', 
                    'img_AIR', 'imgC_AIR', 'typeCode', 'object_type', 'filter', 
                    'remarkEN', 'remarkCN', 'other_numbers', 'con', 'brightness', 
                    'shape', 'radius', 'diameter', 'mass', 'discoverer', 'dYearEN', 
                    'dYearCN', 'vmag1sd', 'vmag2nd', 'cloud_area', 'opacity', 
                    'DesCN', 'DesEn', 'S50', 'recommend_SS', 'rank_SS', 'recommend_ASIAIR'
                  ];
                  
                  const columns = starTableColumns.join(', ');
                  const placeholders = starTableColumns.map(() => '?').join(', ');
                  const insertSQL = `INSERT INTO star_table (${columns}) VALUES (${placeholders})`;
                  
                  const stmt = sqliteDb.prepare(insertSQL);
                  
                  for (const row of parseResult.data) {
                    // 按照star_table的列顺序映射数据
                    const values = starTableColumns.map(colName => {
                      const value = row[colName];
                      if (value == null || value === '') {
                        return null;
                      }
                      return value;
                    });
                    
                    stmt.run(values, (err) => {
                      if (err) {
                        console.error('插入数据失败:', err);
                      }
                    });
                  }
                  
                  stmt.finalize((err) => {
                    if (err) {
                      reject(err);
                      return;
                    }
                    
                    // 关闭数据库连接
                    sqliteDb.close((err) => {
                      if (err) {
                        reject(err);
                      } else {
                        resolve(outputPath);
                      }
                    });
                  });
                } else {
                  // 没有数据时也要关闭数据库
                  sqliteDb.close((err) => {
                    if (err) {
                      reject(err);
                    } else {
                      resolve(outputPath);
                    }
                  });
                }
              });

            } catch (error) {
              reject(error);
            }
          });
        });
      });
    });
  }

  // 生成加密数据库说明文件
  generateEncryptionInstructions(outputPath, password) {
    const instructions = `数据库加密说明
=================

文件: ${path.basename(outputPath)}
加密时间: ${new Date().toISOString()}
加密方式: SQLCipher
密码: ${password}

这是一个使用SQLCipher加密的SQLite数据库文件。
可以使用支持SQLCipher的工具打开，如：
- SQLCipher for Android
- DB Browser for SQLite (with SQLCipher support)
- SQLiteStudio (with SQLCipher plugin)

注意: 请妥善保管密码，丢失密码将无法恢复数据。
`;

    const instructionsPath = outputPath.replace(/\.[^.]+$/, '_instructions.txt');
    fs.writeFileSync(instructionsPath, instructions, 'utf-8');
    
    return instructionsPath;
  }

  // 获取数据库信息
  getDatabaseInfo(dbName) {
    const db = this.databases.get(dbName);
    if (!db) {
      return null;
    }

    const tables = [];
    for (const [tableName, table] of db.tables) {
      tables.push({
        name: tableName,
        columns: table.columns.length,
        rows: table.data.length,
        created: table.created
      });
    }

    return {
      name: db.name,
      tables,
      created: db.created
    };
  }

  // 查询数据（简化版SQL）
  query(dbName, tableName, limit = 100) {
    const db = this.databases.get(dbName);
    if (!db) {
      throw new Error('数据库不存在');
    }

    const table = db.tables.get(tableName);
    if (!table) {
      throw new Error('表不存在');
    }

    return {
      columns: table.columns,
      data: table.data.slice(0, limit),
      total: table.data.length
    };
  }
}

module.exports = JSBackend;